#!/usr/bin/env node

/**
 * 步骤2：对新内容进行多语言翻译
 * 
 * 功能：
 * 1. 读取步骤1生成的新内容文件
 * 2. 对新内容进行多语言翻译
 * 3. 生成或更新语言包文件
 * 4. 输出翻译完成的内容映射
 */

const fs = require('fs');
const path = require('path');

class I18nTranslator {
  constructor() {
    this.projectRoot = path.resolve(__dirname, '../');
    this.i18nPath = path.join(this.projectRoot, 'src/i18n/config');
    
    
    // 支持的语言
    this.supportedLanguages = ['zh', 'en']; // 可以扩展更多语言
    
    // 新内容数据
    this.newContentData = null;
    
    // 翻译结果
    this.translations = {}; // {lang: {key: text}}
    
    console.log('🌐 步骤2：对新内容进行多语言翻译');
    console.log(`📁 项目根目录: ${this.projectRoot}`);
  }

  /**
   * 获取新的未国际化内容
   */
  getNewContent() {
    console.log('\n📚 获取待翻译的新内容...');
    
    const I18nDiscoverer = require('./step1-discover.js');
    const discoverer = new I18nDiscoverer();
    
    // 执行发现过程
    discoverer.loadExistingContent();
    discoverer.scanProjectContent();
    discoverer.findNewContent();
    
    // 转换为所需格式
    const items = [];
    for (const [content, info] of discoverer.newContent) {
      items.push({
        content: content,
        key: info.key,
        locations: info.locations.map(loc => ({
          file: path.relative(this.projectRoot, loc.file),
          line: loc.line,
          context: loc.content
        }))
      });
    }
    
    this.newContentData = {
      timestamp: new Date().toISOString(),
      totalCount: items.length,
      items: items
    };
    
    console.log(`✅ 发现了 ${this.newContentData.totalCount} 个待翻译内容`);
    
    if (this.newContentData.totalCount === 0) {
      console.log('🎉 没有新内容需要翻译！');
      process.exit(0);
    }
    
    // 显示一些示例
    console.log('\n📋 待翻译内容示例:');
    this.newContentData.items.slice(0, 5).forEach(item => {
      console.log(`   "${item.content}" -> ${item.key}`);
    });
    
    if (this.newContentData.items.length > 5) {
      console.log(`   ... 还有 ${this.newContentData.items.length - 5} 个`);
    }
  }

  /**
   * 初始化翻译结果结构
   */
  initializeTranslations() {
    this.supportedLanguages.forEach(lang => {
      this.translations[lang] = {};
    });
  }

  /**
   * 执行翻译
   */
  async performTranslation() {
    console.log('\n🌐 开始翻译...');
    
    this.initializeTranslations();
    
    let processedCount = 0;
    
    for (const item of this.newContentData.items) {
      const { content, key } = item;
      
      // 中文（源语言）
      this.translations.zh[key] = content;
      
      // 翻译到其他语言
      for (const lang of this.supportedLanguages) {
        if (lang !== 'zh') {
          try {
            const translatedText = await this.translateTo(content, lang);
            this.translations[lang][key] = translatedText;
          } catch (error) {
            console.warn(`⚠️ 翻译 "${content}" 到 ${lang} 失败:`, error.message);
            this.translations[lang][key] = `[${content}]`; // 使用原文作为备选
          }
        }
      }
      
      processedCount++;
      if (processedCount % 10 === 0) {
        console.log(`🔄 已翻译 ${processedCount}/${this.newContentData.totalCount} 个内容...`);
      }
      
      // 添加小延迟避免API限制
      await this.delay(100);
    }
    
    console.log(`✅ 翻译完成！共处理 ${processedCount} 个内容`);
  }

  /**
   * 翻译到指定语言
   */
  async translateTo(chineseText, targetLang) {
    // 内置的简单翻译映射
    const translations = this.getBuiltinTranslations();
    
    if (translations[chineseText] && translations[chineseText][targetLang]) {
      return translations[chineseText][targetLang];
    }
    
    // 如果是英文，使用内置的简单翻译逻辑
    if (targetLang === 'en') {
      return this.simpleChineseToEnglish(chineseText);
    }
    
    // 其他语言暂时使用占位符
    return `[${chineseText}_${targetLang}]`;
  }

  /**
   * 同步翻译到指定语言
   */
  translateToSync(chineseText, targetLang) {
    // 内置的简单翻译映射
    const translations = this.getBuiltinTranslations();
    
    if (translations[chineseText] && translations[chineseText][targetLang]) {
      return translations[chineseText][targetLang];
    }
    
    // 如果是英文，使用内置的简单翻译逻辑
    if (targetLang === 'en') {
      return this.simpleChineseToEnglish(chineseText);
    }
    
    // 其他语言暂时使用占位符
    return `[${chineseText}_${targetLang}]`;
  }

  /**
   * 获取内置翻译映射
   */
  getBuiltinTranslations() {
    return {
      '确认': { en: 'Confirm' },
      '取消': { en: 'Cancel' },
      '提交': { en: 'Submit' },
      '保存': { en: 'Save' },
      '删除': { en: 'Delete' },
      '编辑': { en: 'Edit' },
      '添加': { en: 'Add' },
      '新增': { en: 'Add' },
      '搜索': { en: 'Search' },
      '查询': { en: 'Query' },
      '登录': { en: 'Login' },
      '注册': { en: 'Register' },
      '退出': { en: 'Logout' },
      '首页': { en: 'Home' },
      '我的': { en: 'Mine' },
      '个人中心': { en: 'Profile' },
      '设置': { en: 'Settings' },
      '返回': { en: 'Back' },
      '下一步': { en: 'Next' },
      '上一步': { en: 'Previous' },
      '完成': { en: 'Complete' },
      '失败': { en: 'Failed' },
      '成功': { en: 'Success' },
      '错误': { en: 'Error' },
      '警告': { en: 'Warning' },
      '信息': { en: 'Info' },
      '提示': { en: 'Tip' },
      '加载中': { en: 'Loading' },
      '无数据': { en: 'No Data' },
      '暂无数据': { en: 'No Data' },
      '网络错误': { en: 'Network Error' },
      '操作成功': { en: 'Operation Successful' },
      '操作失败': { en: 'Operation Failed' },
      '马拉松': { en: 'Marathon' },
      '比赛': { en: 'Race' },
      '赛事': { en: 'Event' },
      '参赛者': { en: 'Participant' },
      '成绩': { en: 'Result' },
      '证书': { en: 'Certificate' },
      '排名': { en: 'Ranking' },
      '时间': { en: 'Time' },
      '地点': { en: 'Location' },
      '详情': { en: 'Details' },
      '报名': { en: 'Sign Up' },
      '列表': { en: 'List' },
      '全部': { en: 'All' },
      '筛选': { en: 'Filter' },
      '暂无': { en: 'None' },
      '未知': { en: 'Unknown' },
      '开始': { en: 'Start' },
      '结束': { en: 'End' },
      '进行中': { en: 'In Progress' },
      '已结束': { en: 'Finished' },
      '是': { en: 'Yes' },
      '否': { en: 'No' },
      '关闭': { en: 'Close' },
      '打开': { en: 'Open' },
      '刷新': { en: 'Refresh' },
      '重试': { en: 'Retry' },
      '跳过': { en: 'Skip' },
      '继续': { en: 'Continue' },
      '暂停': { en: 'Pause' },
      '停止': { en: 'Stop' },
      '重置': { en: 'Reset' },
      '清空': { en: 'Clear' },
      '全选': { en: 'Select All' },
      '取消选择': { en: 'Deselect' }
    };
  }

  /**
   * 简单的中文到英文翻译逻辑
   */
  simpleChineseToEnglish(chineseText) {
    const text = chineseText.trim();
    
    // 对于短文本，使用描述性翻译
    if (text.length <= 2) {
      return `Text_${text}`;
    }
    
    // 对于问句
    if (text.includes('？') || text.includes('吗')) {
      return `Question_${text}`;
    }
    
    // 对于状态或结果
    if (text.includes('成功') || text.includes('失败') || text.includes('完成')) {
      return `Status_${text}`;
    }
    
    // 对于长文本，使用描述性前缀
    if (text.length > 10) {
      return `Description_${text}`;
    }
    
    // 默认使用Message前缀
    return `Message_${text}`;
  }

  /**
   * 延迟函数
   */
  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  /**
   * 更新语言包文件
   */
  updateLanguageFiles() {
    console.log('\n📝 更新语言包文件...');
    
    for (const lang of this.supportedLanguages) {
      const translations = this.translations[lang];
      if (Object.keys(translations).length === 0) continue;
      
      const langDir = path.join(this.i18nPath, lang);
      const filePath = path.join(langDir, 'auto-generated.js');
      
      // 确保目录存在
      if (!fs.existsSync(langDir)) {
        fs.mkdirSync(langDir, { recursive: true });
      }
      
      // 读取现有文件内容
      let existingTranslations = {};
      if (fs.existsSync(filePath)) {
        try {
          const content = fs.readFileSync(filePath, 'utf8');
          const match = content.match(/export\s+default\s+(\{[\s\S]*\})/);
          if (match) {
            const objStr = match[1]
              .replace(/([{,]\s*)(\w+):/g, '$1"$2":')
              .replace(/'/g, '"');
            existingTranslations = JSON.parse(objStr);
          }
        } catch (error) {
          console.warn(`⚠️ 解析现有文件 ${filePath} 失败，将创建新文件`);
        }
      }
      
      // 合并新旧翻译
      const mergedTranslations = { ...existingTranslations, ...translations };
      
      // 生成文件内容
      const comment = lang === 'zh' ? 
        '// 自动生成的中文语言包' : 
        `// Auto-generated ${lang.toUpperCase()} language pack`;
      
      const content = `${comment}
export default ${JSON.stringify(mergedTranslations, null, 2)}
`;
      
      fs.writeFileSync(filePath, content, 'utf8');
      
      const newKeysCount = Object.keys(translations).length;
      const totalKeysCount = Object.keys(mergedTranslations).length;
      
      console.log(`✅ 已更新 ${lang}/auto-generated.js (新增 ${newKeysCount} 个，总计 ${totalKeysCount} 个)`);
    }
  }


  /**
   * 更新index.js文件以包含auto-generated
   */
  updateIndexFiles() {
    console.log('\n🔗 更新index文件...');
    
    for (const lang of this.supportedLanguages) {
      const indexPath = path.join(this.i18nPath, lang, 'index.js');
      
      if (fs.existsSync(indexPath)) {
        try {
          let content = fs.readFileSync(indexPath, 'utf8');
          
          // 检查是否已经包含auto-generated的导入
          if (!content.includes('auto-generated')) {
            // 添加导入语句
            const importLine = "import autoGenerated from './auto-generated'";
            
            // 在其他import语句后添加
            if (content.includes('import')) {
              content = content.replace(
                /(import[\s\S]*?from\s+['"][^'"]*['"])/g,
                `$1\n${importLine}`
              );
            } else {
              content = `${importLine}\n${content}`;
            }
            
            // 在export default对象中添加展开
            content = content.replace(
              /export\s+default\s+\{/,
              'export default {\n  ...autoGenerated,'
            );
            
            fs.writeFileSync(indexPath, content, 'utf8');
            console.log(`✅ 已更新 ${lang}/index.js 以包含自动生成的翻译`);
          } else {
            console.log(`ℹ️ ${lang}/index.js 已包含自动生成的翻译`);
          }
        } catch (error) {
          console.warn(`⚠️ 更新 ${indexPath} 失败:`, error.message);
        }
      } else {
        console.warn(`⚠️ 未找到 ${indexPath}，请手动创建并导入auto-generated.js`);
      }
    }
  }

  /**
   * 生成报告
   */
  generateReport() {
    console.log('\n📊 翻译报告:');
    console.log('='.repeat(60));
    console.log(`🌐 支持语言: ${this.supportedLanguages.join(', ')}`);
    console.log(`📝 翻译内容: ${this.newContentData.totalCount} 个`);
    
    for (const lang of this.supportedLanguages) {
      const count = Object.keys(this.translations[lang] || {}).length;
      console.log(`   ${lang.toUpperCase()}: ${count} 个条目`);
    }
    
    console.log('='.repeat(60));
    
    console.log('\n💡 下一步：');
    console.log('   运行 node scripts/step3-replace.js 进行源码替换');
  }

  /**
   * 显示翻译示例
   */
  showTranslationExamples() {
    console.log('\n📋 翻译示例:');
    
    const examples = Object.keys(this.translations.zh || {}).slice(0, 5);
    
    examples.forEach(key => {
      console.log(`\n   Key: ${key}`);
      for (const lang of this.supportedLanguages) {
        const text = this.translations[lang][key];
        console.log(`   ${lang.toUpperCase()}: "${text}"`);
      }
    });
    
    if (Object.keys(this.translations.zh || {}).length > 5) {
      const remaining = Object.keys(this.translations.zh || {}).length - 5;
      console.log(`\n   ... 还有 ${remaining} 个翻译`);
    }
  }

  /**
   * 主运行方法
   */
  async run() {
    try {
      // 1. 获取新内容
      this.getNewContent();
      
      // 2. 执行翻译
      await this.performTranslation();
      
      // 3. 更新语言包文件
      this.updateLanguageFiles();
      
      // 4. 更新index文件
      this.updateIndexFiles();
      
      // 5. 显示翻译示例
      this.showTranslationExamples();
      
      // 6. 生成报告
      this.generateReport();
      
      console.log('\n🎉 步骤2完成！');
      
    } catch (error) {
      console.error('❌ 步骤2失败:', error);
      process.exit(1);
    }
  }
}

// 运行脚本
if (require.main === module) {
  const translator = new I18nTranslator();
  translator.run();
}

module.exports = I18nTranslator;